package main

import (
	"calculator/math"
	"fmt"
	"strings"
	"time"
)

// 创建线程
var mid = make(chan struct{})

func main() {
	result := math.Power(2, 3) // 计算 2 的 3 次方
	fmt.Println("2 的 3 次方是：", result)
	drawTriangle(10)
	fmt.Println(toUpper("hello"))

	arr := make([]int, result)
	for i := range arr {
		arr[i] = math.Power(i, 2)
	}
	c := append(arr, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10) //切片追加
	fmt.Println(c)
	fmt.Println(calculateSkuQuantity([]string{"红色", "蓝色"}, []string{"大", "小"}, []string{"薄", "厚"}, []string{"圆", "方"}))
	a := map[string]int{
		"sku1": 10,
		"sku2": 20,
		"sku3": 30,
		"sku4": 40,
	}
	v, ok := a["sku1"] // 判断key的值是否存在
	fmt.Println(a, v, ok)

	type Person struct { // 结构体
		name    string
		age     int8
		address string
	}
	p1 := Person{
		name:    "张三",
		age:     20,
		address: "北京",
	}
	p1.name = "李四"
	fmt.Println(p1.name, p1.age, p1.address)
	// 第二种结构体
	var p2 = new(Person)
	p2.name = "王五"
	p2.age = 30
	p2.address = "上海"
	fmt.Println(p2.name, p2.age, p2.address)

	// panic("半径不能为负") 自定义异常 类似return
	p4 := new(Person)
	fmt.Println(p4)
	// 第三种结构体
	doData(make(chan int))
	s := "abcd"
	// 双重赋值
	for i, n := 0, len(s); i < n; i++ {
		fmt.Print(i, "%%d", n)
	}
	findLucky([]int{2, 2, 3, 4})

}
func doData(channel chan int) {
	time.Sleep(5)
	fmt.Println("暂停五秒", channel)
}

// 解答幸运数 [2,2,3,4] 返回2
func findLucky(arr []int) int {
	st := make(map[int]int)
	for i := 0; i < len(arr); i++ {
		val := arr[i]
		if _, ok := st[val]; ok {
			st[val] = st[val] + 1
		} else {
			st[val] = 1
		}
	}

	result := -1
	for k, v := range st {
		if k == v && k > result {
			result = k
		}
	}
	return result
}

func drawTriangle(height int) {
	for i := 1; i <= height; i++ {
		// 打印每行前面的空格
		for j := 1; j <= height-i; j++ {
			fmt.Print(" ")
		}
		// 打印每行的星号
		for k := 1; k <= 2*i-1; k++ {
			fmt.Print("*")
		}
		// 换行
		fmt.Println()
	}
}

func toUpper(str string) string {
	s1 := []byte(str)
	s1[0] = 'H'
	return string(s1)
}

// 动态计算sku对应的数量  传入四个参数 a b c d 计算出他们能组成的所有项数量
func calculateSkuQuantity(a []string, b []string, c []string, d []string) []string {
	// 创建结果数组
	var result []string
	// 处理空数组的情况
	if len(a) == 0 {
		a = []string{""}
	}
	if len(b) == 0 {
		b = []string{""}
	}
	if len(c) == 0 {
		c = []string{""}
	}
	if len(d) == 0 {
		d = []string{""}
	}
	// 定义连接符
	separator := "-"
	// 使用四层嵌套循环计算笛卡尔积
	for _, valA := range a {
		for _, valB := range b {
			for _, valC := range c {
				for _, valD := range d {
					// 构建组合字符串，移除空值和多余的连接符
					parts := []string{}

					if valA != "" {
						parts = append(parts, valA)
					}
					if valB != "" {
						parts = append(parts, valB)
					}
					if valC != "" {
						parts = append(parts, valC)
					}
					if valD != "" {
						parts = append(parts, valD)
					}
					// 使用连接符将非空部分连接起来
					combination := strings.Join(parts, separator)
					// 只添加非空组合
					if combination != "" {
						result = append(result, combination)
					}
				}
			}
		}
	}
	return result
}
